// 修复后的 api.js - 社交模块添加调试信息
const API_BASE_URL = 'http://119.3.210.45:8080';

const api = {
// 在api.js中添加以下方法到api对象中

    // 获取所有作品（带分页）
    async getWorks(token, orderBy = 'createTime', pageNum = 1, pageSize = 100) {
        try {
            const url = `${API_BASE_URL}/work/get_works?orderBy=${orderBy}&pageNum=${pageNum}&pageSize=${pageSize}`;

            console.log('=== 获取作品列表请求开始 ===');
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'GET',  // 明确指定GET
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 获取作品列表成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '获取作品列表失败');
            }
        } catch (error) {
            console.error('=== 获取作品列表异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },
    // 在你的 api.js 的 api 对象中添加以下方法

    // 获取资源封面图片
    async getCover(token, coverPath) {
        try {
            console.log('=== 获取资源封面请求开始 ===');
            console.log('封面路径:', coverPath);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            // 如果没有路径，使用默认路径
            const path = coverPath || 'cover/default.png';
            const url = `${API_BASE_URL}/work/getCover?coverPath=${encodeURIComponent(path)}`;

            console.log('请求URL:', url);

            const headers = {};
            if (token) {
                const cleanToken = token.trim().replace(/\s+/g, '');
                headers['Authorization'] = cleanToken;
            }

            const response = await fetch(url, {
                method: 'GET',
                headers: headers
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查响应的内容类型
            const contentType = response.headers.get('content-type');
            console.log('响应内容类型:', contentType);

            if (response.status === 200) {
                if (contentType && contentType.startsWith('image/')) {
                    // 如果是图片，返回blob
                    const blob = await response.blob();
                    console.log('=== 获取封面成功（图片格式） ===');
                    console.log('图片大小:', blob.size, 'bytes');
                    return blob;
                } else if (contentType && contentType.includes('application/json')) {
                    // 如果是JSON响应，可能是错误信息
                    const data = await response.json();
                    console.log('封面JSON响应:', data);

                    // 检查业务逻辑是否成功
                    if (data.status === 301 || data.msg === 'TOKEN验证失败') {
                        console.error('TOKEN验证失败:', data);
                        throw new Error(data.msg || 'TOKEN验证失败，请重新登录');
                    }

                    throw new Error(data.msg || '获取封面失败');
                } else {
                    // 其他情况，尝试作为blob处理
                    const blob = await response.blob();
                    console.log('=== 获取封面成功（未知格式，作为blob处理） ===');
                    return blob;
                }
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                throw new Error(`获取封面失败: HTTP ${response.status}`);
            }
        } catch (error) {
            console.error('=== 获取资源封面异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 获取封面图片URL的辅助方法
    getCoverUrl(token, coverPath) {
        const path = coverPath || 'cover/default.png';
        const url = `${API_BASE_URL}/work/getCover?coverPath=${encodeURIComponent(path)}`;

        // 如果有token，添加到URL中（但注意：这种方式可能不安全，建议使用上面的方法）
        if (token) {
            return `${url}&token=${encodeURIComponent(token)}`;
        }

        return url;
    },

    // 根据名称搜索作品
    async searchByName(token, name) {
        try {
            const url = `${API_BASE_URL}/work/search_by_name?name=${encodeURIComponent(name)}`;

            console.log('=== 按名称搜索作品请求开始 ===');
            console.log('搜索关键词:', name);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 按名称搜索作品成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '搜索作品失败');
            }
        } catch (error) {
            console.error('=== 按名称搜索作品异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },

    // 删除作品（用户删除自己的作品）
    async deleteUserWork(token, workId) {
        try {
            const url = `${API_BASE_URL}/work/deleteWork?workId=${workId}`;

            console.log('=== 删除用户作品请求开始 ===');
            console.log('作品ID:', workId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!workId) {
                throw new Error('作品ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 删除用户作品成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '删除作品失败');
            }
        } catch (error) {
            console.error('=== 删除用户作品异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },

    // 管理员删除作品
    async adminDeleteWork(token, workId) {
        try {
            const url = `${API_BASE_URL}/admin/delete_work?workId=${workId}`;

            console.log('=== 管理员删除作品请求开始 ===');
            console.log('作品ID:', workId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!workId) {
                throw new Error('作品ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 管理员删除作品成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '删除作品失败');
            }
        } catch (error) {
            console.error('=== 管理员删除作品异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },

    // 获取带标签的作品列表（带分页）
    async getWorksWithTags(token, tags = [], orderBy = 'createTime', pageNum = 1, pageSize = 100) {
        try {
            let url = `${API_BASE_URL}/work/get_works_with_tags?orderBy=${orderBy}&pageNum=${pageNum}&pageSize=${pageSize}`;

            if (tags.length > 0) {
                const tagsParam = tags.map(tag => encodeURIComponent(tag)).join(',');
                url += `&tags=${tagsParam}`;
            }

            console.log('=== 获取带标签作品列表请求开始 ===');
            console.log('标签:', tags);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 获取带标签作品列表成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '获取作品列表失败');
            }
        } catch (error) {
            console.error('=== 获取带标签作品列表异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },

    // 管理员获取所有作品列表
    async adminGetAllWorks(token, pageNum = 1, pageSize = 100) {
        try {
            const url = `${API_BASE_URL}/admin/get_all_works?pageNum=${pageNum}&pageSize=${pageSize}`;

            console.log('=== 管理员获取所有作品请求开始 ===');
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 管理员获取所有作品成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '获取作品列表失败');
            }
        } catch (error) {
            console.error('=== 管理员获取所有作品异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },

    // 设置作品价格（管理员功能）
    async setWorkCost(token, workId, newCost) {
        try {
            const url = `${API_BASE_URL}/work/setWorkCost?workId=${workId}&newCost=${newCost}`;

            console.log('=== 设置作品价格请求开始 ===');
            console.log('作品ID:', workId);
            console.log('新价格:', newCost);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!workId || newCost === undefined) {
                throw new Error('作品ID和新价格不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                console.log('=== 设置作品价格成功 ===');
                return result;
            } else {
                throw new Error(result.msg || '设置价格失败');
            }
        } catch (error) {
            console.error('=== 设置作品价格异常 ===');
            console.error('错误信息:', error.message);
            throw error;
        }
    },
    // 获取用户头像 - 增强版本
    async getUserAvatar(token, avatarPath = '') {
        try {
            const url = `${API_BASE_URL}/user/getUserAvatar?avatarPath=${encodeURIComponent(avatarPath)}`;

            console.log('=== 获取用户头像请求开始 ===');
            console.log('头像路径:', avatarPath);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查响应的内容类型
            const contentType = response.headers.get('content-type');
            console.log('头像响应内容类型:', contentType);

            if (response.status === 200) {
                if (contentType && contentType.includes('image')) {
                    // 如果是图片，返回blob
                    const blob = await response.blob();
                    console.log('=== 获取头像成功（图片格式） ===');
                    return blob;
                } else if (contentType && contentType.includes('application/json')) {
                    // 如果是JSON响应，可能包含base64数据或错误信息
                    const data = await response.json();
                    console.log('头像JSON响应:', data);

                    // 检查业务逻辑是否成功
                    if (data.status === 301 || data.msg === 'TOKEN验证失败') {
                        console.error('TOKEN验证失败:', data);
                        throw new Error(data.msg || 'TOKEN验证失败，请重新登录');
                    }

                    console.log('=== 获取头像成功（JSON格式） ===');
                    return data;
                } else {
                    // 其他情况，尝试作为文本处理
                    const text = await response.text();
                    console.log('头像文本响应:', text);
                    console.log('=== 获取头像成功（文本格式） ===');
                    return text;
                }
            } else {
                const errorData = await response.json().catch(() => ({}));
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', errorData.msg);
                throw new Error(errorData.msg || '获取头像失败');
            }
        } catch (error) {
            console.error('=== 获取用户头像异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 获取用户passkey - 新增方法
    async getPasskey(token) {
        try {
            const url = `${API_BASE_URL}/user/getPasskey`;

            console.log('=== 获取用户passkey请求开始 ===');
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            if (response.status === 200) {
                const result = await response.json();
                console.log('Passkey完整响应数据:', result);
                console.log('响应数据类型:', typeof result);
                console.log('响应数据结构:', Object.keys(result || {}));

                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }

                // 根据API文档，成功响应格式为：
                // {
                //   "status": 200,
                //   "msg": "操作成功",
                //   "data": "string"
                // }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `获取passkey失败，状态码: ${result.status}`);
                }

                console.log('=== 获取passkey成功 ===');
                return result;
            } else {
                const errorData = await response.json().catch(() => ({}));
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', errorData.msg);
                throw new Error(errorData.msg || '获取passkey失败');
            }
        } catch (error) {
            console.error('=== 获取用户passkey异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },
    // ========== 管理员模块 API ==========

// 管理员获取所有帖子
    async getAdminAllPosts(token) {
        try {
            const url = `${API_BASE_URL}/admin/post/getAllPosts`;

            console.log('=== 管理员获取所有帖子请求开始 ===');
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            const result = await response.json();
            console.log('完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `获取帖子列表失败，状态码: ${result.status}`);
                }
                console.log('=== 管理员获取所有帖子成功 ===');
                return result;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result.msg);
                throw new Error(result.msg || '获取帖子列表失败');
            }
        } catch (error) {
            console.error('=== 管理员获取所有帖子异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

// 管理员删除帖子
    async adminDeletePost(token, postId) {
        try {
            const url = `${API_BASE_URL}/admin/post/deletePost?postId=${postId}`;

            console.log('=== 管理员删除帖子请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId) {
                throw new Error('帖子ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'DELETE',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查是否有返回内容
            const contentType = response.headers.get('content-type');
            console.log('响应内容类型:', contentType);

            let result = null;
            if (contentType && contentType.includes('application/json')) {
                result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);
                console.log('响应数据结构:', Object.keys(result || {}));
            } else {
                console.log('无JSON响应内容或内容为空');
            }

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result && result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `删除帖子失败，状态码: ${result.status}`);
                }
                console.log('=== 管理员删除帖子成功 ===');
                return true;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result?.msg);
                throw new Error(result?.msg || '删除帖子失败');
            }
        } catch (error) {
            console.error('=== 管理员删除帖子异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

// 管理员设置帖子置顶
    async adminStickyPost(token, postId) {
        try {
            const url = `${API_BASE_URL}/admin/post/stickyPost?postId=${postId}`;

            console.log('=== 管理员设置帖子置顶请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId) {
                throw new Error('帖子ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查是否有返回内容
            const contentType = response.headers.get('content-type');
            console.log('响应内容类型:', contentType);

            let result = null;
            if (contentType && contentType.includes('application/json')) {
                result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);
                console.log('响应数据结构:', Object.keys(result || {}));
            } else {
                console.log('无JSON响应内容或内容为空');
            }

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result && result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `设置置顶失败，状态码: ${result.status}`);
                }
                console.log('=== 管理员设置帖子置顶成功 ===');
                return true;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result?.msg);
                throw new Error(result?.msg || '设置置顶失败');
            }
        } catch (error) {
            console.error('=== 管理员设置帖子置顶异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

// 管理员取消帖子置顶
    async adminUnstickyPost(token, postId) {
        try {
            const url = `${API_BASE_URL}/admin/post/unstickyPost?postId=${postId}`;

            console.log('=== 管理员取消帖子置顶请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId) {
                throw new Error('帖子ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查是否有返回内容
            const contentType = response.headers.get('content-type');
            console.log('响应内容类型:', contentType);

            let result = null;
            if (contentType && contentType.includes('application/json')) {
                result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);
                console.log('响应数据结构:', Object.keys(result || {}));
            } else {
                console.log('无JSON响应内容或内容为空');
            }

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result && result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `取消置顶失败，状态码: ${result.status}`);
                }
                console.log('=== 管理员取消帖子置顶成功 ===');
                return true;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result?.msg);
                throw new Error(result?.msg || '取消置顶失败');
            }
        } catch (error) {
            console.error('=== 管理员取消帖子置顶异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },
    // 获取验证码
    async getVerifyCode(username, emailAddr, isLogin) {
        try {
            const response = await fetch(
                `${API_BASE_URL}/user/verifyCode?username=${username}&emailAddr=${emailAddr}&isLogin=${isLogin}`
            );
            return await response.json();
        } catch (error) {
            console.error('获取验证码失败:', error);
            throw error;
        }
    },

    // 用户登录
    async login(loginData) {
        try {
            const response = await fetch(`${API_BASE_URL}/user/login`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(loginData)
            });
            const result = await response.json();
            if (response.status === 200) {
                console.log('登录成功，返回数据:', result);
                return result;
            } else {
                throw new Error(result.msg || '登录失败');
            }
        } catch (error) {
            console.error('登录失败:', error);
            throw error;
        }
    },

    // 用户注册
    async register(formData) {
        try {
            console.log('FormData entries:');
            for (let [key, value] of formData.entries()) {
                console.log(key, value);
            }

            const response = await fetch(`${API_BASE_URL}/user/register`, {
                method: 'POST',
                body: formData
            });

            console.log('Response status:', response.status);

            const result = await response.json();
            if (response.status === 200) {
                return result;
            } else {
                throw new Error(result.msg || '注册失败');
            }
        } catch (error) {
            console.error('注册失败:', error);
            throw error;
        }
    },

    // 获取用户信息 - 修复版本
    async getUserInfo(token) {
        try {
            if (!token) {
                throw new Error('Token 为空');
            }

            // 清理 token（移除可能的空格和换行符）
            const cleanToken = token.trim().replace(/\s+/g, '');

            console.log('请求用户信息，原始token:', token);
            console.log('清理后的token:', cleanToken);
            console.log('Token格式检查:', cleanToken ? '有效' : '无效');
            console.log('Token长度:', cleanToken?.length);
            console.log('Token开头:', cleanToken?.substring(0, 20));
            console.log('Token结尾:', cleanToken?.substring(cleanToken.length - 20));

            // 验证 JWT 格式
            const parts = cleanToken.split('.');
            if (parts.length !== 3) {
                throw new Error(`Token 格式错误：应该有3个部分，实际有${parts.length}个`);
            }

            console.log('最终的 Authorization header:', cleanToken.substring(0, 30) + '...');

            const response = await fetch(`${API_BASE_URL}/user/getUserInfo`, {
                headers: {
                    'Authorization': cleanToken // 直接使用 token，不添加 Bearer 前缀
                }
            });

            console.log('获取用户信息响应状态:', response.status);

            const result = await response.json();
            console.log('获取用户信息完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('业务逻辑失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }

                // 检查是否有 status 字段且不等于 1（假设 1 表示成功）
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('API业务状态异常:', result.status);
                    throw new Error(result.msg || `API调用失败，状态码: ${result.status}`);
                }

                // 根据API文档，可能需要返回 result.data 或直接返回 result
                const userData = result.data || result;
                console.log('最终返回的用户数据:', userData);
                return userData;
            } else {
                throw new Error(result.msg || '获取用户信息失败');
            }
        } catch (error) {
            console.error('获取用户信息失败:', error);
            throw error;
        }
    },

    // 更新用户信息
    async updateUserInfo(token, updateData) {
        try {
            console.log('更新用户信息请求，token:', token?.substring(0, 20) + '...');
            console.log('更新数据:', updateData);

            const response = await fetch(`${API_BASE_URL}/user/updateInfo`, {
                method: 'POST',
                headers: {
                    'Authorization': token, // 直接使用 token，不添加 Bearer 前缀
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(updateData)
            });

            const result = await response.json();
            console.log('更新用户信息响应:', result);

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '更新用户信息失败');
            }
        } catch (error) {
            console.error('更新用户信息失败:', error);
            throw error;
        }
    },

    // 获取邀请码
    async getInvitationCode(token, remaining) {
        try {
            console.log('获取邀请码请求，token:', token?.substring(0, 20) + '...');

            const response = await fetch(
                `${API_BASE_URL}/user/getInvitationCode?remaining=${remaining}`,
                {
                    headers: {
                        'Authorization': token // 直接使用 token，不添加 Bearer 前缀
                    }
                }
            );

            const result = await response.json();
            console.log('获取邀请码响应:', result);

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取邀请码失败');
            }
        } catch (error) {
            console.error('获取邀请码失败:', error);
            throw error;
        }
    },



    // ========== 社交模块 API - 添加token验证 ==========

    // 获取帖子列表
    async getPosts(token = null, userId = null, page = 1, size = 10) {
        try {
            let url = `${API_BASE_URL}/social/posts?page=${page}&size=${size}`;
            if (userId) {
                url += `&userId=${userId}`;
            }

            console.log('=== 获取帖子列表请求开始 ===');
            console.log('请求URL:', url);
            console.log('请求参数:', { userId, page, size });
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            const headers = {};
            if (token) {
                const cleanToken = token.trim().replace(/\s+/g, '');
                headers['Authorization'] = cleanToken;
                console.log('添加Authorization头');
            }

            const response = await fetch(url, { headers });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应头信息:', Object.fromEntries(response.headers));
            console.log('响应是否成功:', response.ok);

            const result = await response.json();
            console.log('完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `获取帖子列表失败，状态码: ${result.status}`);
                }
                console.log('=== 获取帖子列表成功 ===');
                return result;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result.msg);
                throw new Error(result.msg || '获取帖子列表失败');
            }
        } catch (error) {
            console.error('=== 获取帖子列表异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 获取单个帖子详情
    async getPost(token, postId) {
        try {
            const url = `${API_BASE_URL}/social/posts/${postId}`;

            console.log('=== 获取帖子详情请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId) {
                throw new Error('帖子ID不能为空');
            }

            const headers = {};
            if (token) {
                const cleanToken = token.trim().replace(/\s+/g, '');
                headers['Authorization'] = cleanToken;
            }

            const response = await fetch(url, { headers });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            const result = await response.json();
            console.log('完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `获取帖子详情失败，状态码: ${result.status}`);
                }
                console.log('=== 获取帖子详情成功 ===');
                return result;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result.msg);
                throw new Error(result.msg || '获取帖子详情失败');
            }
        } catch (error) {
            console.error('=== 获取帖子详情异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 创建帖子
    async createPost(token, postData) {
        try {
            const url = `${API_BASE_URL}/social/posts`;

            console.log('=== 创建帖子请求开始 ===');
            console.log('请求URL:', url);
            console.log('帖子数据:', postData);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');
            console.log('数据序列化:', JSON.stringify(postData));

            if (!postData) {
                throw new Error('帖子数据不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': cleanToken
                },
                body: JSON.stringify(postData)
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应头信息:', Object.fromEntries(response.headers));

            const result = await response.json();
            console.log('完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `创建帖子失败，状态码: ${result.status}`);
                }
                console.log('=== 创建帖子成功 ===');
                return result;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result.msg);
                throw new Error(result.msg || '创建帖子失败');
            }
        } catch (error) {
            console.error('=== 创建帖子异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 获取帖子评论列表
    async getComments(token, postId, page = 1, size = 10) {
        try {
            const url = `${API_BASE_URL}/social/posts/${postId}/comments?page=${page}&size=${size}`;

            console.log('=== 获取评论列表请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('页码:', page);
            console.log('每页数量:', size);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId) {
                throw new Error('帖子ID不能为空');
            }

            const headers = {};
            if (token) {
                const cleanToken = token.trim().replace(/\s+/g, '');
                headers['Authorization'] = cleanToken;
            }

            const response = await fetch(url, { headers });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            const result = await response.json();
            console.log('完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `获取评论失败，状态码: ${result.status}`);
                }
                console.log('=== 获取评论列表成功 ===');
                return result;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result.msg);
                throw new Error(result.msg || '获取评论失败');
            }
        } catch (error) {
            console.error('=== 获取评论列表异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 创建评论
    async createComment(token, commentData) {
        try {
            const url = `${API_BASE_URL}/social/comments`;

            console.log('=== 创建评论请求开始 ===');
            console.log('请求URL:', url);
            console.log('评论数据:', commentData);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');
            console.log('数据序列化:', JSON.stringify(commentData));

            if (!commentData) {
                throw new Error('评论数据不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': cleanToken
                },
                body: JSON.stringify(commentData)
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应头信息:', Object.fromEntries(response.headers));

            const result = await response.json();
            console.log('完整响应数据:', result);
            console.log('响应数据类型:', typeof result);
            console.log('响应数据结构:', Object.keys(result || {}));

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `发表评论失败，状态码: ${result.status}`);
                }
                console.log('=== 创建评论成功 ===');
                return result;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result.msg);
                throw new Error(result.msg || '发表评论失败');
            }
        } catch (error) {
            console.error('=== 创建评论异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 点赞帖子
    async likePost(token, postId, userId) {
        try {
            const url = `${API_BASE_URL}/social/posts/${postId}/like?userId=${userId}`;

            console.log('=== 点赞帖子请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('用户ID:', userId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId || !userId) {
                throw new Error('帖子ID和用户ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查是否有返回内容
            const contentType = response.headers.get('content-type');
            console.log('响应内容类型:', contentType);

            let result = null;
            if (contentType && contentType.includes('application/json')) {
                result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);
                console.log('响应数据结构:', Object.keys(result || {}));
            } else {
                console.log('无JSON响应内容或内容为空');
            }

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result && result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `点赞失败，状态码: ${result.status}`);
                }
                console.log('=== 点赞帖子成功 ===');
                return true;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result?.msg);
                throw new Error(result?.msg || '点赞失败');
            }
        } catch (error) {
            console.error('=== 点赞帖子异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 取消点赞
    async unlikePost(token, postId, userId) {
        try {
            const url = `${API_BASE_URL}/social/posts/${postId}/like?userId=${userId}`;

            console.log('=== 取消点赞请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('用户ID:', userId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId || !userId) {
                throw new Error('帖子ID和用户ID不能为空');
            }
            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(url, {
                method: 'DELETE',
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            // 检查是否有返回内容
            const contentType = response.headers.get('content-type');
            console.log('响应内容类型:', contentType);

            let result = null;
            if (contentType && contentType.includes('application/json')) {
                result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);
                console.log('响应数据结构:', Object.keys(result || {}));
            } else {
                console.log('无JSON响应内容或内容为空');
            }

            if (response.status === 200) {
                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                if (result && result.status && result.status !== 1 && result.status !== 200) {
                    console.error('业务逻辑失败 - 状态码:', result.status);
                    console.error('业务逻辑失败 - 错误信息:', result.msg);
                    throw new Error(result.msg || `取消点赞失败，状态码: ${result.status}`);
                }
                console.log('=== 取消点赞成功 ===');
                return true;
            } else {
                console.error('HTTP请求失败 - 状态码:', response.status);
                console.error('HTTP请求失败 - 错误信息:', result?.msg);
                throw new Error(result?.msg || '取消点赞失败');
            }
        } catch (error) {
            console.error('=== 取消点赞异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('错误堆栈:', error.stack);
            throw error;
        }
    },

    // 检查点赞状态
    async hasLiked(token, postId, userId) {
        try {
            const url = `${API_BASE_URL}/social/posts/${postId}/hasLiked?userId=${userId}`;

            console.log('=== 检查点赞状态请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('用户ID:', userId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId || !userId) {
                console.warn('帖子ID或用户ID为空，返回false');
                return false;
            }

            const headers = {};
            if (token) {
                const cleanToken = token.trim().replace(/\s+/g, '');
                headers['Authorization'] = cleanToken;
            }

            const response = await fetch(url, { headers });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            if (response.status === 200) {
                const result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);

                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }

                console.log('=== 检查点赞状态成功 ===');
                return result;
            } else {
                console.warn('检查点赞状态失败，返回false');
                return false;
            }
        } catch (error) {
            console.error('=== 检查点赞状态异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('返回默认值: false');
            return false;
        }
    },

    // 获取点赞数
    async getLikeCount(token, postId) {
        try {
            const url = `${API_BASE_URL}/social/posts/${postId}/likeCount`;

            console.log('=== 获取点赞数请求开始 ===');
            console.log('帖子ID:', postId);
            console.log('请求URL:', url);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!postId) {
                console.warn('帖子ID为空，返回0');
                return 0;
            }

            const headers = {};
            if (token) {
                const cleanToken = token.trim().replace(/\s+/g, '');
                headers['Authorization'] = cleanToken;
            }

            const response = await fetch(url, { headers });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);
            console.log('响应是否成功:', response.ok);

            if (response.status === 200) {
                const result = await response.json();
                console.log('完整响应数据:', result);
                console.log('响应数据类型:', typeof result);

                // 检查业务逻辑是否成功
                if (result && (result.status === 301 || result.msg === 'TOKEN验证失败')) {
                    console.error('TOKEN验证失败:', result);
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }

                console.log('=== 获取点赞数成功 ===');
                return result;
            } else {
                console.warn('获取点赞数失败，返回0');
                return 0;
            }
        } catch (error) {
            console.error('=== 获取点赞数异常 ===');
            console.error('错误类型:', error.name);
            console.error('错误信息:', error.message);
            console.error('返回默认值: 0');
            return 0;
        }
    },

    // ========== 资源模块 API ==========

    // 创建资源
    async createWork(token, formData) {
        try {
            console.log('=== 创建资源请求开始 ===');
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');
            console.log('FormData entries:');
            for (let [key, value] of formData.entries()) {
                console.log(key, value);
            }

            const response = await fetch(`${API_BASE_URL}/work/createWork`, {
                method: 'POST',
                headers: {
                    'Authorization': token
                },
                body: formData
            });

            const result = await response.json();
            console.log('创建资源响应:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '创建资源失败');
            }
        } catch (error) {
            console.error('创建资源失败:', error);
            throw error;
        }
    },
    // 获取所有作品资源
    async getAllWorks(token) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/search_by_name?name=`, {
                headers: {
                    'Authorization': token
                }
            });

            const result = await response.json();
            
            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取所有资源失败');
            }
        } catch (error) {
            console.error('获取所有资源失败:', error);
            throw error;
        }
    },

    // 获取热门标签
    async getHottestTags(token) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/getHottestTags`, {
                headers: {
                    'Authorization': token
                }
            });
            const result = await response.json();
            
            if (response.status === 200) {
                return result;
            } else {
                throw new Error(result.msg || '获取热门标签失败');
            }
        } catch (error) {
            console.error('获取热门标签失败:', error);
            throw error;
        }
    },

    // 购买资源
    async purchaseWork(token, workId) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/purchaseWork?workId=${workId}`, {
                method: 'POST',
                headers: {
                    'Authorization': token,
                    'Content-Type': 'application/json'
                }
            });

            const result = await response.json();
            
            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '购买资源失败');
            }
        } catch (error) {
            console.error('购买资源失败:', error);
            throw error;
        }
    },

    // 获取资源种子文件
    async getWorkTorrent(token, workId) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/getWorkTorrent?workId=${workId}`, {
                method: 'POST',
                headers: {
                    'Authorization': token,
                    'Content-Type': 'application/json'
                }
            });

            if (response.status === 200) {
                const blob = await response.blob();
                const url = window.URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = `work-${workId}.torrent`;
                document.body.appendChild(a);
                a.click();
                window.URL.revokeObjectURL(url);
                document.body.removeChild(a);
                return true;
            } else {
                const result = await response.json();
                throw new Error(result.msg || '获取种子文件失败');
            }
        } catch (error) {
            console.error('获取种子文件失败:', error);
            throw error;
        }
    },

    // 删除资源
    async deleteWork(token, work) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/deleteWork`, {
                method: 'POST',
                headers: {
                    'Authorization': token,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(work)
            });

            const result = await response.json();
            
            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '删除资源失败');
            }
        } catch (error) {
            console.error('删除资源失败:', error);
            throw error;
        }
    },

    // 获取已拥有的资源
    async getPossessWork(token) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/get_possess_work`, {
                headers: {
                    'Authorization': token
                }
            });

            const result = await response.json();
            
            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取已拥有资源失败');
            }
        } catch (error) {
            console.error('获取已拥有资源失败:', error);
            throw error;
        }
    },

    // 获取用户创建的资源
    async getUserCreatedWork(token) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/get_user_create_work`, {
                headers: {
                    'Authorization': token
                }
            });

            const result = await response.json();
            
            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取用户创建资源失败');
            }
        } catch (error) {
            console.error('获取用户创建资源失败:', error);
            throw error;
        }
    },

    // 获取用户购买的资源
    async getUserPurchasedWork(token) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/get_user_purchase_work`, {
                headers: {
                    'Authorization': token
                }
            });

            const result = await response.json();
            
            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取用户购买资源失败');
            }
        } catch (error) {
            console.error('获取用户购买资源失败:', error);
            throw error;
        }
    },

    // 根据标签搜索资源
    async searchByTags(token, tags) {
        try {
            const response = await fetch(`${API_BASE_URL}/work/search_by_tags`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': token
                },
                body: JSON.stringify(tags)
            });

            const result = await response.json();
            
            if (response.status === 200) {
                return result;
            } else {
                throw new Error(result.msg || '搜索资源失败');
            }
        } catch (error) {
            console.error('搜索资源失败:', error);
            throw error;
        }
    },

    // 管理员设置作品促销
    async setWorkOnSale(token, workId, onSale, netRate, costRate) {
        try {
            const response = await fetch(
                `${API_BASE_URL}/admin/set_on_sale?workId=${workId}&onSale=${onSale}&netRate=${netRate}&costRate=${costRate}`,
                {
                    method: 'POST',
                    headers: {
                        'Authorization': token,
                        'Content-Type': 'application/json'
                    }
                }
            );

            const result = await response.json();

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '设置促销失败');
            }
        } catch (error) {
            console.error('设置促销失败:', error);
            throw error;
        }
    },

    // 获取用户偏好标签
    async getFavoriteTags(token, userId, tagsNum) {
        try {
            console.log('=== 获取用户偏好标签请求开始 ===');
            console.log('用户ID:', userId);
            console.log('标签数量:', tagsNum);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(
                `${API_BASE_URL}/work/get_favorite_tags?userId=${userId}&tagsNum=${tagsNum}`,
                {
                    headers: {
                        'Authorization': cleanToken
                    }
                }
            );

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取用户偏好标签失败');
            }
        } catch (error) {
            console.error('获取用户偏好标签失败:', error);
            throw error;
        }
    },

    // ========== 管理员模块 API ==========

    // 启动作弊分析
    async bootCheatAnalysis(token) {
        try {
            console.log('=== 启动作弊分析请求开始 ===');
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(`${API_BASE_URL}/admin/bootCheatAnalysis`, {
                headers: {
                    'Authorization': cleanToken
                }
            });

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '启动作弊分析失败');
            }
        } catch (error) {
            console.error('启动作弊分析失败:', error);
            throw error;
        }
    },

    // 获取用户管理列表
    async getUserAdminList(token, pageNum, pageSize) {
        try {
            console.log('=== 获取用户管理列表请求开始 ===');
            console.log('页码:', pageNum);
            console.log('每页数量:', pageSize);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(
                `${API_BASE_URL}/admin/getUserAdminList?pageNum=${pageNum}&pageSize=${pageSize}`,
                {
                    headers: {
                        'Authorization': cleanToken
                    }
                }
            );

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取用户管理列表失败');
            }
        } catch (error) {
            console.error('获取用户管理列表失败:', error);
            throw error;
        }
    },

    // 获取分析结果
    async getAnalysisResult(token, userId) {
        try {
            console.log('=== 获取分析结果请求开始 ===');
            console.log('用户ID:', userId);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(
                `${API_BASE_URL}/admin/getAnalysisResult?userId=${userId}`,
                {
                    headers: {
                        'Authorization': cleanToken
                    }
                }
            );

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '获取分析结果失败');
            }
        } catch (error) {
            console.error('获取分析结果失败:', error);
            throw error;
        }
    },

    // 封禁用户
    async banned(token, userId) {
        try {
            console.log('=== 封禁用户请求开始 ===');
            console.log('用户ID:', userId);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(
                `${API_BASE_URL}/admin/banned?userId=${userId}`,
                {
                    method: 'POST',
                    headers: {
                        'Authorization': cleanToken
                    }
                }
            );

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '封禁用户失败');
            }
        } catch (error) {
            console.error('封禁用户失败:', error);
            throw error;
        }
    },

    // 解封用户
    async unbanned(token, userId) {
        try {
            console.log('=== 解封用户请求开始 ===');
            console.log('用户ID:', userId);
            console.log('Token:', token ? token.substring(0, 20) + '...' : '无');

            if (!token) {
                throw new Error('Token不能为空，请先登录');
            }

            const cleanToken = token.trim().replace(/\s+/g, '');

            const response = await fetch(
                `${API_BASE_URL}/admin/unbanned?userId=${userId}`,
                {
                    method: 'POST',
                    headers: {
                        'Authorization': cleanToken
                    }
                }
            );

            console.log('响应状态码:', response.status);
            console.log('响应状态文本:', response.statusText);

            const result = await response.json();
            console.log('完整响应数据:', result);

            if (response.status === 200) {
                if (result.status === 301 || result.msg === 'TOKEN验证失败') {
                    throw new Error(result.msg || 'TOKEN验证失败，请重新登录');
                }
                return result;
            } else {
                throw new Error(result.msg || '解封用户失败');
            }
        } catch (error) {
            console.error('解封用户失败:', error);
            throw error;
        }
    }
};

export default api;